home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / boot / netBoot.new / pixrect.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-19  |  8.4 KB  |  231 lines
  1.  
  2. /*    @(#)pixrect.h 1.1 86/09/27 SMI    */
  3.  
  4. /*
  5.  * Copyright (c) 1986 by Sun Microsystems, Inc.
  6.  */
  7.  
  8. /*
  9.  * This file defines the programmer interface to the pixrect abstraction.
  10.  * A pixrect is a rectangular array of pixels on which a number of
  11.  * operations are defined.
  12.  *
  13.  * Each pixrect has as visible attributes its height and width in
  14.  * pixels and the number of bits stored for each pixel.  It also supports
  15.  * several operations.  The proper way to think of the operations is
  16.  * that they are messages sent to the pixrect.  The operations are:
  17.  *
  18.  *    pr_destroy    destroy a pixrect
  19.  *    pr_rop        raster operation from another pixrect to the
  20.  *            destination pixrect.  the case where the source
  21.  *            and destination overlap is properly handled.
  22.  *    pr_stencil    raster operation from source pixrect to the
  23.  *            dest pixrect using a stencil pixrect as a 'cookie
  24.  *            cutter' to perform a spatial write enable.
  25.  *    pr_batchrop    like pr_rop, but source is an array of pixrects,
  26.  *            and an offset to be applied before each pixrect.
  27.  *            overlapping source and destination not allowed.
  28.  *            this is specifically designed for operations like
  29.  *            putting up text, which consists of a number of
  30.  *            characters from a font, each given by a pixrect.
  31.  *    pr_get        get the value of a single pixel from a pixrect
  32.  *    pr_put        change a single pixel value in a pixrect
  33.  *    pr_vector    draws a vector in a pixrect
  34.  *    pr_region    create a new pixrect which describes a rectangular
  35.  *            sub-region of an existing pixrect
  36.  *    pr_putcolormap    writes a portion of the colormap alias intensity
  37.  *            transformation table.
  38.  *    pr_getcolormap    reads a portion of the colormap
  39.  *    pr_putattributes set the bitplanes attributes.
  40.  *    pr_getattributes get the bitplanes attributes.
  41.  *            
  42.  * Abbreviations:
  43.  *    src, s            source
  44.  *    dst, dest, d        destination
  45.  *    sten, st        stencil
  46.  *    b, bp            batch or batch pointer
  47.  *    pr            pixrect
  48.  *    pos            position
  49.  */
  50.  
  51. /*
  52.  * There are a number of concepts used in the arguments to pixrects:
  53.  *
  54.  *    struct pr_pos        a position within a pixrect is a pair of
  55.  *                integers giving the offset from the upper
  56.  *                left corner.  the pixels within a pixrect
  57.  *                are numbered with (0,0) at the upper left
  58.  *                and (width-1,height-1) at the lower right.
  59.  *    struct pr_prpos        is a pixrect and a position within it.
  60.  *    struct pr_size        is a pair of integers representing the
  61.  *                size of a rectangle within a pixrect.
  62.  *    struct pr_subregion    is a pixrect, a position and a size,
  63.  *                specifying a rectangular sub-region.
  64.  */
  65. struct pr_pos {
  66.     int    x, y;
  67. };
  68. struct pr_prpos {
  69.     struct    pixrect *pr;
  70.     struct    pr_pos pos;
  71. };
  72. struct pr_size {
  73.     int    x, y;
  74. };
  75. struct pr_subregion {
  76.     struct    pixrect *pr;
  77.     struct    pr_pos pos;
  78.     struct    pr_size size;
  79. };
  80. struct pixrect {
  81.     struct    pixrectops *pr_ops;    /* operations appropriate to this pr */
  82.     struct    pr_size pr_size;    /* pixels per dimension */
  83.     int    pr_depth;        /* bits per pixel */
  84.     caddr_t    pr_data;        /* device-dependent pixel-access */
  85. };
  86. #define pr_width    pr_size.x
  87. #define pr_height    pr_size.y
  88.  
  89. #ifndef KERNEL
  90. /*
  91.  * Takes device file name.  This is how first pixrect is created.
  92.  */
  93. extern    struct pixrect *pr_open();
  94. #endif !KERNEL
  95.  
  96. /*
  97.  * The general pixrect operations, defined on all pixrects, are as follows.
  98.  * They are obtained from the pr_ops attribute of the pixrect being operated
  99.  * on.  Where two pixrects are involved the operations are obtained from
  100.  * the destination pixrect.
  101.  */
  102. struct pixrectops {
  103.     int    (*pro_rop)();        /* raster-op pixrect to pixrect */
  104. #ifndef KERNEL
  105.     int    (*pro_stencil)();    /* raster-op with stencil to pixrect */
  106.     int    (*pro_batchrop)();    /* raster-op batch to pixrect */
  107.     int    (*pro_nop)();        /* place holder */
  108.     int    (*pro_destroy)();    /* destroy this pixrect */
  109.     int    (*pro_get)();        /* get value from pixrect */
  110.     int    (*pro_put)();        /* store value in pixrect */
  111.     int    (*pro_vector)();    /* write vector to pixrect */
  112.     struct pixrect *
  113.         (*pro_region)();    /* make pixrect for region */
  114. #endif !KERNEL
  115.     int    (*pro_putcolormap)();    /* write intensity xform table */
  116. #ifndef KERNEL
  117.     int    (*pro_getcolormap)();    /* read intensity xform table */
  118. #endif !KERNEL
  119.     int    (*pro_putattributes)();    /* write pr color attributes */
  120. #ifndef KERNEL
  121.     int    (*pro_getattributes)();    /* read pr color attributes */
  122. #endif !KERNEL
  123. };
  124.  
  125. #define pr_rop(dpr, dx, dy, w, h, op, spr, sx, sy)        \
  126.     (*(dpr)->pr_ops->pro_rop)(dpr, dx, dy, w, h, op, spr, sx, sy)
  127. #define    pr_putcolormap(pr, ind, cnt, red, grn, blu)        \
  128.     (*(pr)->pr_ops->pro_putcolormap)(pr, ind, cnt, red, grn, blu)
  129. #define    pr_putattributes(pr, planes)                    \
  130.     (*(pr)->pr_ops->pro_putattributes)(pr, planes)
  131. #ifndef KERNEL
  132. #define pr_stencil(dpr, dx, dy, w, h, op, stpr, stx, sty, spr, sx, sy)    \
  133.     (*(dpr)->pr_ops->pro_stencil)(dpr,dx,dy,w,h,op,stpr,stx,sty,spr,sx,sy)
  134. #define pr_batchrop(dpr, x, y, op, sbp, n)            \
  135.     (*(dpr)->pr_ops->pro_batchrop)(dpr, x, y, op, sbp, n)
  136. #define pr_destroy(pr)                            \
  137.     (*(pr)->pr_ops->pro_destroy)(pr)
  138. #define    pr_get(pr, x, y)                        \
  139.     (*(pr)->pr_ops->pro_get)(pr, x, y)
  140. #define    pr_put(pr, x, y, val)                        \
  141.     (*(pr)->pr_ops->pro_put)(pr, x, y, val)
  142. #define pr_vector(pr, x0, y0, x1, y1, op, color)            \
  143.     (*(pr)->pr_ops->pro_vector)(pr, x0, y0, x1, y1, op, color)
  144. #define    pr_region(pr, x, y, w, h)                    \
  145.     (*(pr)->pr_ops->pro_region)(pr, x, y, w, h)
  146. #define    pr_getcolormap(pr, ind, cnt, red, grn, blu)        \
  147.     (*(pr)->pr_ops->pro_getcolormap)(pr, ind, cnt, red, grn, blu)
  148. #define    pr_getattributes(pr, planes)                    \
  149.     (*(pr)->pr_ops->pro_getattributes)(pr, planes)
  150. #endif !KERNEL
  151.  
  152. /*
  153.  * Several of the above operations return a common, distinguished value when
  154.  * an error arises.  That value is defined as follows:
  155.  */
  156. #define PIX_ERR    -1
  157.  
  158. /*
  159.  * Operations.  In the case of depth=1 pixrects the 'op' in 'rasterop' may be
  160.  * any binary Boolean function, encoded as a non-negative integer < 16,
  161.  * the op code.  The function is applied per-pixel.  
  162.  *
  163.  * The following permit the op to be expressed as Boolean combinations
  164.  * of the two inputs 'source' and 'dest'.  Thus oring the source and destination
  165.  * together is written as PIX_SRC|PIX_DST, while xoring the source with the
  166.  * destination is PIX_SRC^PIX_DST.  Since ~op is negative, the macro PIX_NOT
  167.  * is provided for use in place of ~.  For bit plane mask operations
  168.  * PIX_PLN may be included in the boolean combination for depth 8 pixrects.
  169.  */
  170. #define    PIX_SRC        (0xC << 1)
  171. #define    PIX_DST        (0xA << 1)
  172. #define PIX_NOT(op)    ((0xf<<1)&(~op))        /* clean ~op */
  173. #define    PIX_CLR        (PIX_SRC&PIX_NOT(PIX_SRC))    /* background */
  174. #define    PIX_SET        (PIX_SRC|PIX_NOT(PIX_SRC))    /* foreground */
  175. #define PIX_COLOR(c)    ((c)<<5)
  176. #define PIX_OPCOLOR(op)    ((op)>>5)
  177.  
  178. /*
  179.  * Macro which tells whether a rasterop needs a SRC or DST.
  180.  */
  181.  
  182. #define    PIXOP_NEEDS_DST(op)        ( (((op)>>1)^(op)) & PIX_NOT(PIX_DST))
  183. #define    PIXOP_NEEDS_SRC(op)        ( (((op)>>2)^(op)) & PIX_NOT(PIX_SRC))
  184.  
  185. /*
  186.  * The pseudo-operation PIX_DONTCLIP specifies that clipping should not
  187.  * be performed.
  188.  */
  189. /* The constants PIX_CLIP specifies that clipping should occur.
  190.  * The TEST specifies that just testing is done NO benchmarking.
  191.  * and NO_TEST specifies that benchmarking should be done.
  192.  */
  193. #define    PIX_DONTCLIP        0x1
  194. #define PIX_CLIP        0x0
  195. #define TEST            0x1
  196. #define NO_TEST            0x0
  197.  
  198. /*
  199.  * The following structured definitions, all prefixed with prs_, correspond
  200.  * to the unstructured definitions above prefixed with pr_.
  201.  */
  202. #define prs_rop(dstregion, op, srcprpos)            \
  203.     (*((dstregion).pr)->pr_ops->pro_rop)(dstregion, op, srcprpos)
  204. #define prs_stencil(dstregion, op, stenprpos, srcprpos)            \
  205.     (*((dstregion).pr)->pr_ops->pro_stencil)            \
  206.             (dstregion, op, stenprpos, srcprpos)
  207. #define prs_batchrop(dstpos, op, srcbatch, n)                \
  208.     (*((dstpos).pr)->pr_ops->pro_batchrop)(dstpos,op,srcbatch,n)
  209. #define prs_destroy(pr)                            \
  210.     (*(pr)->pr_ops->pro_destroy)(pr);
  211. #define    prs_get(srcprpos)                        \
  212.     (*((srcprpos).pr)->pr_ops->pro_get)(srcprpos)
  213. #define    prs_put(dstprpos, val)                        \
  214.     (*((dstprpos).pr)->pr_ops->pro_put)(dstprpos, val)
  215. #define prs_vector(pr, coord0, coord1, op, color)            \
  216.     (*(pr)->pr_ops->pro_vector)(pr, coord0, coord1, op, color)
  217. #define    prs_region(dstregion)                        \
  218.     (*(dstregion.pr)->pr_ops->pro_region)(dstregion)
  219. #define    prs_putcolormap(pr, ind, cnt, red, grn, blu)        \
  220.     (*(pr)->pr_ops->pro_putcolormap)(pr, ind, cnt, red, grn, blu)
  221. #define    prs_getcolormap(pr, ind, cnt, red, grn, blu)        \
  222.     (*(pr)->pr_ops->pro_getcolormap)(pr, ind, cnt, red, grn, blu)
  223. #define    prs_putattributes(pr, planes)                    \
  224.     (*(pr)->pr_ops->pro_putattributes)(pr, planes)
  225. #define    prs_getattributes(pr, planes)                    \
  226.     (*(pr)->pr_ops->pro_getattributes)(pr, planes)
  227.  
  228. struct    singlecolor {
  229.     u_char    red, green, blue;
  230. };
  231.